#include <stdio.h>
#include <stdbool.h>

#define MaxSize 10 // 队列的最大容量
typedef struct
{
    int data[MaxSize]; // 静态数组存储队列元素
    int front;         // 队头指针
    int rear;          // 队尾指针
    int count;         // 队列中元素个数（可选）
} CircularQueue;

// 1. 初始化循环队列
void InitQueue(CircularQueue &Q)
{
    Q.front = 0; // 队头指针初始为0
    Q.rear = 0;  // 队尾指针初始为0
    Q.count = 0; // 元素个数初始为0
}

// 2. 销毁循环队列
void DestroyQueue(CircularQueue &Q)
{
    Q.front = 0;
    Q.rear = 0;
    Q.count = 0;
}

// 3. 入队操作
bool EnQueue(CircularQueue &Q, int x)
{
    if (Q.count == MaxSize)
    { // 队满判断
        printf("Queue is full!\n");
        return false;
    }
    Q.data[Q.rear] = x;              // 存入队尾
    Q.rear = (Q.rear + 1) % MaxSize; // 循环后移队尾指针
    Q.count++;                       // 元素计数增加
    return true;
}

// 4. 出队操作
bool DeQueue(CircularQueue &Q, int &x)
{
    if (Q.count == 0)
    { // 队空判断
        printf("Queue is empty!\n");
        return false;
    }
    x = Q.data[Q.front];               // 获取队头元素
    Q.front = (Q.front + 1) % MaxSize; // 循环后移队头指针
    Q.count--;                         // 元素计数减少
    return true;
}

// 5. 获取队头元素
bool GetHead(CircularQueue Q, int &x)
{
    if (Q.count == 0)
    { // 队空判断
        printf("Queue is empty!\n");
        return false;
    }
    x = Q.data[Q.front];
    return true;
}

// 6. 获取队尾元素
bool GetTail(CircularQueue Q, int &x)
{
    if (Q.count == 0)
    { // 队空判断
        printf("Queue is empty!\n");
        return false;
    }
    int tailPos = (Q.rear - 1 + MaxSize) % MaxSize; // 计算队尾位置
    x = Q.data[tailPos];
    return true;
}

// 7. 判空操作
bool IsEmpty(CircularQueue Q)
{
    return (Q.count == 0);
}

// 8. 判满操作
bool IsFull(CircularQueue Q)
{
    return (Q.count == MaxSize);
}

// 打印队列内容（从队头到队尾）
void PrintQueue(CircularQueue Q)
{
    if (IsEmpty(Q))
    {
        printf("Queue is empty\n");
        return;
    }

    printf("Queue [front->rear]: ");
    int i = Q.front;
    int elements = Q.count;
    while (elements--)
    {
        printf("%d ", Q.data[i]);
        i = (i + 1) % MaxSize;
    }
    printf("\n");
}

int main()
{
    CircularQueue Q;
    InitQueue(Q); // 初始化循环队列

    // 入队操作
    for (int i = 1; i <= 5; i++)
    {
        EnQueue(Q, i * 10);
    }
    PrintQueue(Q); // Queue [front->rear]: 10 20 30 40 50

    // 获取队头和队尾
    int head, tail;
    GetHead(Q, head);
    GetTail(Q, tail);
    printf("Head: %d, Tail: %d\n", head, tail); // Head: 10, Tail: 50

    // 出队操作
    int dequeued;
    DeQueue(Q, dequeued);
    printf("Dequeued: %d\n", dequeued); // Dequeued: 10
    PrintQueue(Q);                      // Queue [front->rear]: 20 30 40 50

    // 循环特性测试
    printf("Testing circular nature:\n");
    for (int i = 0; i < MaxSize - 1; i++)
    {
        EnQueue(Q, i + 100);
    }
    PrintQueue(Q); // 应该显示满队列

    // 判空和判满测试
    printf("Is empty? %s\n", IsEmpty(Q) ? "true" : "false");
    printf("Is full? %s\n", IsFull(Q) ? "true" : "false");

    // 队列空测试
    printf("Testing queue empty:\n");
    while (DeQueue(Q, dequeued))
    {
        printf("Dequeued: %d\n", dequeued);
    }

    // 打印空队列
    PrintQueue(Q);
    printf("Is empty? %s\n", IsEmpty(Q) ? "true" : "false");

    DestroyQueue(Q); // 销毁队列
    return 0;
}